use crate::error::{Result, PipitError}; 
use crate::compiler::{Token, ASTNode}; 
use crate::vm::{Instruction, ModuleRegistry}; 

// 编译阶段接口 
pub trait CompilationStage<I, O> {
    fn process(&mut self, input: I) -> Result<O>;
}

// 词法分析阶段 
pub struct LexicalAnalysisStage {
    // 可以添加配置参数
}

impl LexicalAnalysisStage {
    pub fn new() -> Self {
        LexicalAnalysisStage {}
    }
}

impl CompilationStage<&str, Vec<Token>> for LexicalAnalysisStage {
    fn process(&mut self, source: &str) -> Result<Vec<Token>> {
        // 委托给现有的Lexer实现
        use crate::compiler::Lexer; 
        
        let mut lexer = Lexer::new(source);
        let mut tokens = Vec::new();
        
        loop {
            let token = lexer.next_token()?;
            tokens.push(token.clone());
            
            if token == Token::Eof {
                break;
            }
        }
        
        Ok(tokens)
    }
}

// 语法分析阶段 
pub struct SyntaxAnalysisStage {
    // 可以添加配置参数
}

impl SyntaxAnalysisStage {
    pub fn new() -> Self {
        SyntaxAnalysisStage {}
    }
}

impl CompilationStage<Vec<Token>, Box<ASTNode>> for SyntaxAnalysisStage {
    fn process(&mut self, tokens: Vec<Token>) -> Result<Box<ASTNode>> {
        // 委托给现有的Parser实现
        use crate::compiler::Parser; 
        
        if tokens.is_empty() {
            return Err(PipitError::CompileError("No tokens to parse".to_string()));
        }
        
        // 创建一个临时的源字符串，用于创建Parser
        // 注意：这种实现方式有局限性，因为真实的源代码和token序列可能不完全匹配
        let dummy_source = "dummy source code"; 
        let mut parser = Parser::new(dummy_source)?;
        
        // 我们需要直接调用Parser的parse方法，而不是尝试修改其内部状态
        // 这里我们假设Parser::parse方法可以处理我们的token序列
        // 在实际生产环境中，我们应该重构Parser以支持直接传入tokens
        parser.parse()
    }
}

// 语义分析阶段 
pub struct SemanticAnalysisStage {
    module_registry: ModuleRegistry,
    imported_modules: Vec<crate::vm::Module>,
    // 其他语义分析所需状态
}

impl SemanticAnalysisStage {
    pub fn new() -> Self {
        SemanticAnalysisStage {
            module_registry: ModuleRegistry::new(),
            imported_modules: Vec::new(),
        }
    }
}

impl CompilationStage<Box<ASTNode>, Box<ASTNode>> for SemanticAnalysisStage {
    fn process(&mut self, ast: Box<ASTNode>) -> Result<Box<ASTNode>> {
        // 在这里实现语义分析逻辑
        // 例如：变量声明检查、类型检查、作用域分析等
        // 目前返回原始AST
        Ok(ast)
    }
}

// 代码生成阶段 
pub struct CodeGenerationStage {
    // 委托给现有的Compiler实现
    compiler: crate::compiler::Compiler,
}

impl CodeGenerationStage {
    pub fn new() -> Self {
        CodeGenerationStage {
            compiler: crate::compiler::Compiler::new(),
        }
    }
}

impl CompilationStage<Box<ASTNode>, Vec<Instruction>> for CodeGenerationStage {
    fn process(&mut self, ast: Box<ASTNode>) -> Result<Vec<Instruction>> {
        // 创建一个新的编译器实例，而不是尝试重置现有实例的私有字段
        let mut compiler = crate::compiler::Compiler::new();
        
        // 生成字节码
        compiler.generate_bytecode(&ast)?;
        
        // 添加程序结束指令
        compiler.append_instruction(Instruction::Halt);
        
        // 使用公共方法获取字节码的副本
        Ok(compiler.get_bytecode_clone())
    }
}

// 导入新的前端和后端模块
use crate::frontend::{CompilerFrontend, SemanticAnalyzer};
use crate::backend::{CompilerBackend};
use crate::advanced_optimizations::{OptimizationLevel};

// 编译流水线 
pub struct CompilationPipeline {
    // 使用新的前端和后端实现
    frontend: CompilerFrontend,
    semantic_analyzer: SemanticAnalyzer,
    backend: CompilerBackend,
    
    // 保留旧的阶段实现以保持向后兼容性
    lexical_analysis: LexicalAnalysisStage,
    syntax_analysis: SyntaxAnalysisStage,
    semantic_analysis_old: SemanticAnalysisStage,
    code_generation: CodeGenerationStage,
}

impl CompilationPipeline {
    pub fn new() -> Self {
        CompilationPipeline {
            // 初始化新的前端和后端，使用激进优化级别，启用JIT
            frontend: CompilerFrontend::new(),
            semantic_analyzer: SemanticAnalyzer::new(),
            backend: CompilerBackend::new(OptimizationLevel::Aggressive, true),
            
            // 初始化旧的阶段实现
            lexical_analysis: LexicalAnalysisStage::new(),
            syntax_analysis: SyntaxAnalysisStage::new(),
            semantic_analysis_old: SemanticAnalysisStage::new(),
            code_generation: CodeGenerationStage::new(),
        }
    }
    
    // 使用新的前端/后端架构执行完整编译流程
    pub fn compile(&mut self, source: &str) -> Result<Vec<Instruction>> {
        if source.is_empty() {
            return Err(PipitError::CompileError("Cannot compile empty source".to_string()));
        }
        
        // 1. 前端：解析源代码生成AST
        let ast = self.frontend.parse(source)?;
        
        // 2. 语义分析：检查和优化AST
        let analyzed_ast = self.semantic_analyzer.analyze(ast)?;
        
        // 3. 后端：生成并优化字节码
        self.backend.generate_optimized_bytecode(analyzed_ast)
    }
    
    // 使用旧的流水线架构（用于向后兼容性）
    pub fn compile_with_legacy_pipeline(&mut self, source: &str) -> Result<Vec<Instruction>> {
        if source.is_empty() {
            return Err(PipitError::CompileError("Cannot compile empty source".to_string()));
        }
        
        // 1. 词法分析
        let tokens = self.lexical_analysis.process(source)?;
        
        // 2. 语法分析
        let ast = self.syntax_analysis.process(tokens)?;
        
        // 3. 语义分析
        let analyzed_ast = self.semantic_analysis_old.process(ast)?;
        
        // 4. 代码生成
        self.code_generation.process(analyzed_ast)
    }
    
    // 获取模块注册表
    pub fn get_module_registry(&self) -> &ModuleRegistry {
        // 注意：这里返回的是后端的模块注册表
        // 实际应该确保前后端的模块注册表是同步的
        todo!("Synchronize module registry between frontend and backend")
    }
    
    // 重置流水线状态
    pub fn reset(&mut self) {
        self.frontend = CompilerFrontend::new();
        self.semantic_analyzer = SemanticAnalyzer::new();
        self.backend = CompilerBackend::new(OptimizationLevel::Aggressive, true);
        
        self.lexical_analysis = LexicalAnalysisStage::new();
        self.syntax_analysis = SyntaxAnalysisStage::new();
        self.semantic_analysis_old = SemanticAnalysisStage::new();
        self.code_generation = CodeGenerationStage::new();
    }
    
    // 设置优化级别
    pub fn set_optimization_level(&mut self, level: OptimizationLevel) {
        // 需要创建一个新的后端实例，因为OptimizationLevel是不可变的
        let enable_jit = self.backend.get_jit_compiler().is_some();
        self.backend = CompilerBackend::new(level, enable_jit);
    }
    
    // 启用或禁用JIT编译
    pub fn set_jit_enabled(&mut self, enabled: bool) {
        // 需要创建一个新的后端实例
        let optimization_level = self.backend.get_optimization_level();
        self.backend = CompilerBackend::new(optimization_level, enabled);
    }
}